home *** CD-ROM | disk | FTP | other *** search
/ Amiga Plus 2004 #2 / Amiga Plus CD - 2004 - No. 02.iso / AmiSoft / Disk / moni / FileX-src.lha / FileX-src / settings.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-05-16  |  11.2 KB  |  521 lines
  1. #include "allprotos.h"
  2.  
  3. #include "FileXStructs.h"
  4. #include "FileXStrings.h"
  5.  
  6. #define ID_FLEX    MAKE_ID('F','L','E','X')    /* FileX - Chunk */
  7. #define ID_PREF    MAKE_ID('P','R','E','F')    /* PreferencesID */
  8.  
  9. UBYTE SettingsFullName[256];
  10. UBYTE ARexxCommandSettingsFullName[256];
  11.  
  12. /*
  13.  * BOOL LoadSettings( UBYTE *Name, BOOL quiet )
  14.  * 
  15.  * Läd Settings ein und setzt diese.
  16.  * Falls quiet = TRUE, kein Requester bei Fehlern
  17.  */
  18.  
  19. BOOL LoadSettings( UBYTE *Name, BOOL quiet )
  20. {
  21.     struct IFFHandle *Handle;
  22.     BOOL Success = FALSE;
  23.  
  24.     if(Handle = AllocIFF())
  25.     {
  26.     if(Handle -> iff_Stream = Open(Name,MODE_OLDFILE))
  27.     {
  28.     InitIFFasDOS(Handle);
  29.  
  30.     if(!OpenIFF(Handle,IFFF_READ))
  31.     {
  32.     if(!StopChunk(Handle,ID_PREF,ID_FLEX))
  33.     if(!ParseIFF(Handle,IFFPARSE_SCAN))
  34.     {
  35.         union { UBYTE *bptr; UWORD *wptr; ULONG *lptr; } ptr;
  36.  
  37.         UWORD version;
  38.         LONG SettingsBufferLen;
  39.         APTR SettingsBuffer;
  40.  
  41.             /* Versionsnummer des Files einlesen und überprüfen */
  42.         
  43.         if( ReadChunkBytes( Handle, &version, 2 ))
  44.         if( version == 3 )
  45.         {
  46.         if( ReadChunkBytes( Handle, &SettingsBufferLen, 4 ))
  47.         {
  48.                 /* Speicher für den Buffer allokieren und die Daten einlesen */
  49.  
  50.             if( ptr.bptr = SettingsBuffer = AllocMem( SettingsBufferLen, MEMF_ANY ))
  51.             {
  52.                 ULONG new_screenflags;
  53.                 UWORD new_fhöhe;
  54.                 UWORD FontNameLen, commandshellwindowlen,    commandwindowlen;
  55.                 WORD new_displaytyp;
  56.  
  57.                 if( ReadChunkBytes( Handle, SettingsBuffer, SettingsBufferLen ))
  58.                 {
  59.                     DefaultBPR                        = *ptr.wptr++;
  60.                     DefaultZeilen                    = *ptr.lptr++;
  61.                     DefaultLeft            = *ptr.wptr++;
  62.                     DefaultTop                = *ptr.wptr++;
  63.  
  64.                     SetClipboardUnit( *ptr.wptr++ );
  65.                     SetRequester( *ptr.wptr++ );
  66.  
  67.                     if( *ptr.wptr++ )
  68.                         mainflags |= MF_OVERWRITE;
  69.                     else
  70.                         mainflags &= ~MF_OVERWRITE;
  71.  
  72.                     altsprungweite                = *ptr.wptr++;
  73.                     SetScrollRand( *ptr.wptr++ );
  74.                     SetMaxUndoMemSize( *ptr.wptr++ );
  75.                     SetUndoLevel( *ptr.wptr++ );
  76.                     SetTaskPri( FindTask( 0 ), taskpri = *ptr.wptr++);
  77.                     DefaultDisplayForm                    = *ptr.wptr++;
  78.                     DefaultDisplaySpaces                = *ptr.wptr++;
  79.  
  80.                     new_screenflags            = *ptr.wptr++;
  81.                     new_fhöhe                    = *ptr.wptr++;
  82.  
  83.                     commandwindowlen            = *ptr.wptr++;
  84.                     commandshellwindowlen    = *ptr.wptr++;
  85.                     FontNameLen                    = *ptr.wptr++;
  86.                     new_displaytyp                = *ptr.wptr++;
  87.  
  88.                     switch( new_screenflags )
  89.                     {
  90.                         case SF_PUBLIC:
  91.                             if( *ptr.wptr )
  92.                             {
  93.                                 SetSollPublicScreenName( ptr.bptr + 2 );
  94.  
  95.                                 ptr.bptr += *ptr.wptr + 2;
  96.                             }
  97.                              break;
  98.  
  99.                         case SF_OWN_PUBLIC:
  100.                             {
  101.                                 ULONG k, Color;
  102.  
  103.                                 SetScreenModeData( TRUE,    *ptr.lptr,
  104.                                                                     *(ptr.lptr + 1),
  105.                                                                     *(ptr.lptr + 2),
  106.                                                                     *(ptr.wptr + 6),
  107.                                                                     *(ptr.wptr + 7),
  108.                                                                     *(ptr.wptr + 8));
  109.  
  110.                                 ptr.bptr += 18;
  111.  
  112.                                 for( k = 0; k < 8; k++ )
  113.                                 {
  114.                                     Color = *ptr.lptr++;
  115.  
  116.                                     ScreenColors[k].ColorIndex = k;
  117.                                     ScreenColors[k].Red   = ( Color >> 8 ) & 0xf;
  118.                                     ScreenColors[k].Green = ( Color >> 4 ) & 0xf;
  119.                                     ScreenColors[k].Blue  = ( Color      ) & 0xf;
  120.                                 }
  121.                             }
  122.  
  123.                             break;
  124.                     }
  125.  
  126.                     if(commandwindowlen)
  127.                     {
  128.                         SetCommandWindow( ptr.bptr );
  129.                         ptr.bptr += commandwindowlen;
  130.                     }
  131.  
  132.                     if(commandshellwindowlen)
  133.                     {
  134.                         SetCommandShellWindow( ptr.bptr );
  135.                         ptr.bptr += commandshellwindowlen;
  136.                     }
  137.  
  138.                     if( FontNameLen )
  139.                     {
  140.                         MySetFontNameSize( ptr.bptr, new_fhöhe, 0 );
  141.                         ptr.bptr += FontNameLen;
  142.                     }
  143.  
  144.                     if( new_displaytyp == 3 )
  145.                     {
  146.                         memcpy( displaytab[ 3 ], ptr.bptr, 256 );
  147.                         *ptr.bptr += 256;
  148.                     }
  149.  
  150.                     if( Scr ) ReopenDisplay( new_screenflags );
  151.                     else
  152.                     {
  153.                         ScreenFlags = new_screenflags;
  154.                     }
  155.                     Success = TRUE;
  156.                 }
  157.  
  158.                 FreeMem( SettingsBuffer, SettingsBufferLen );
  159.             }
  160.         }
  161.         }
  162.         else
  163.         {
  164.             MyRequest( MSG_INFO_GLOBAL_UNKNOWNVERSIONCANTLOADSETTINGS, ( ULONG )Name );
  165.             quiet = TRUE;
  166.         }
  167.     }
  168.     CloseIFF(Handle);
  169.     }
  170.     Close(Handle -> iff_Stream);
  171.     }
  172.     FreeIFF(Handle);
  173.     }
  174.  
  175.     if(( !quiet ) && ( !Success ))
  176.         MyRequest( MSG_INFO_GLOBAL_CANTLOADSETTINGS, ( ULONG )Name );
  177.  
  178.     if(Success)
  179.         strcpy( SettingsFullName, Name );
  180.  
  181.     return(Success);
  182. }
  183.  
  184. BOOL LoadSettingsFR(void)
  185. {
  186.     if( MyRequestFile( SettingsFullName, GetStr( MSG_WINDOWTITLE_LOADSETTINGS ), "#?.prefs", FALSE ))
  187.         return( LoadSettings( SettingsFullName,FALSE ));
  188.     else
  189.         return( FALSE );
  190. }
  191.  
  192. void LoadSettingsDefault(void)
  193. {
  194.     if(!LoadSettings("FileX.prefs",TRUE))
  195.         LoadSettings("ENVARC:FileX/FileX.prefs",TRUE);
  196. }
  197.  
  198.  
  199. BOOL SaveSettings( UBYTE *Name, BOOL quiet )
  200. {
  201.     struct IFFHandle *Handle;
  202.     BOOL Success = FALSE;
  203.  
  204.     if(Handle = AllocIFF())
  205.     {
  206.     if(Handle -> iff_Stream = Open(Name,MODE_NEWFILE))
  207.     {
  208.     InitIFFasDOS(Handle);
  209.  
  210.     if(!OpenIFF(Handle,IFFF_WRITE))
  211.     {
  212.     if(!PushChunk(Handle,ID_PREF,ID_FORM,IFFSIZE_UNKNOWN))
  213.     if(!PushChunk(Handle,0,ID_FLEX,IFFSIZE_UNKNOWN))
  214.     {
  215.         UWORD version = 3;
  216.         
  217.         if( WriteChunkBytes( Handle, &version, 2 ))
  218.         {
  219.             union { UBYTE *bptr; UWORD *wptr; ULONG *lptr; } ptr;
  220.  
  221.             APTR SettingsBuffer;
  222.             LONG SettingsBufferLen;
  223.  
  224.             UWORD FontNameLen, commandshellwindowlen, commandwindowlen;
  225.  
  226.  
  227.                 /* Längen der variabellangen Daten bestimmen */
  228.  
  229.             commandwindowlen = strlen( arexxcommandwindow ) + 1;
  230.             commandshellwindowlen = strlen( arexxcommandshellwindow ) + 1;
  231.             FontNameLen = strlen( AktuDI->TextFont->tf_Message.mn_Node.ln_Name ) + 1;
  232.  
  233.  
  234.                 /* Gesamtlänge des Zwischenspeichers berechenen */
  235.  
  236.             SettingsBufferLen = 42 + FontNameLen + commandwindowlen + commandshellwindowlen;
  237.             if( AktuDD->DisplayTyp == 3 ) SettingsBufferLen += 256;
  238.  
  239.             switch( ScreenFlags )
  240.             {
  241.                 case SF_PUBLIC:
  242.                     SettingsBufferLen += 2 + strlen( SollPublicScreenName ) + 1;
  243.                      break;
  244.  
  245.                 case SF_OWN_PUBLIC:
  246.                     SettingsBufferLen += 18 + 8 * 4;
  247.                      break;
  248.             }
  249.  
  250.                 /* Zwischenspeicher in einem Rutsch speichern */
  251.             
  252.             if( WriteChunkBytes( Handle, &SettingsBufferLen, 4 ))
  253.             if( ptr.bptr = SettingsBuffer = AllocMem( SettingsBufferLen, MEMF_ANY ))
  254.             {
  255.                 DefaultBPR = *ptr.wptr++ = AktuDD->BPR;
  256.                 DefaultZeilen = *ptr.lptr++ = AktuDD->Zeilen;
  257.                 DefaultLeft = *ptr.wptr++ = AktuDI->Wnd->LeftEdge;
  258.                 DefaultTop = *ptr.wptr++ = AktuDI->Wnd->TopEdge;
  259.  
  260.                 *ptr.wptr++ = GetClipboardUnit();
  261.                 *ptr.wptr++ = UseAsl;
  262.                 *ptr.wptr++ = (mainflags & MF_OVERWRITE) ? TRUE : FALSE;
  263.                 *ptr.wptr++ = altsprungweite;
  264.                 *ptr.wptr++ = realscrollrand;
  265.                 *ptr.wptr++ = maxundomemsize;
  266.                 *ptr.wptr++ = UndoLevel;
  267.                 *ptr.wptr++ = taskpri;
  268.                 DefaultDisplayForm = *ptr.wptr++ = AktuDD->DisplayForm;
  269.                 DefaultDisplaySpaces = *ptr.wptr++ = AktuDD->DisplaySpaces;
  270.  
  271.                 *ptr.wptr++ = ScreenFlags;
  272.                 DefaultFontSize = *ptr.wptr++ = AktuDI->fhöhe;
  273.                 strcpy( DefaultFontName, AktuDI->TextFont->tf_Message.mn_Node.ln_Name );
  274.  
  275.                 *ptr.wptr++ = commandwindowlen;
  276.                 *ptr.wptr++ = commandshellwindowlen;
  277.                 *ptr.wptr++ = FontNameLen;
  278.                 DefaultDisplayTyp = *ptr.wptr++ = AktuDD->DisplayTyp;
  279.  
  280.                 switch( ScreenFlags )
  281.                 {
  282.                     case SF_PUBLIC:
  283.                         {
  284.                             WORD PSNLen = strlen( SollPublicScreenName ) + 1;
  285.  
  286.                             *ptr.wptr++ = PSNLen;
  287.  
  288.                             if( PSNLen )
  289.                             {
  290.                                 memcpy( ptr.bptr, SollPublicScreenName, PSNLen );
  291.                                 ptr.bptr += PSNLen;
  292.                             }
  293.                         }
  294.                          break;
  295.  
  296.                     case SF_OWN_PUBLIC:
  297.                         *ptr.lptr++ = ScreenModeData.smd_DisplayID;
  298.                         *ptr.lptr++ = ScreenModeData.smd_DisplayWidth;
  299.                         *ptr.lptr++ = ScreenModeData.smd_DisplayHeight;
  300.                         *ptr.wptr++ = ScreenModeData.smd_DisplayDepth;
  301.                         *ptr.wptr++ = ScreenModeData.smd_OverscanType;
  302.                         *ptr.wptr++ = ScreenModeData.smd_AutoScroll;
  303.  
  304.                         {
  305.                             ULONG color, k;
  306.  
  307.                             for( k = 0; k < 8; k++ )
  308.                             {
  309.                                 color = GetRGB4( Scr->ViewPort.ColorMap, k );
  310.  
  311.                                 *ptr.lptr++ = color;
  312.                             }
  313.                         }
  314.  
  315.                          break;
  316.                 }
  317.  
  318.                 if( commandwindowlen )
  319.                 {
  320.                     memcpy( ptr.bptr, arexxcommandwindow, commandwindowlen );
  321.                     ptr.bptr += commandwindowlen;
  322.                 }
  323.  
  324.                 if( commandshellwindowlen )
  325.                 {
  326.                     memcpy( ptr.bptr, arexxcommandshellwindow, commandshellwindowlen );
  327.                     ptr.bptr += commandshellwindowlen;
  328.                 }
  329.  
  330.                 if( FontNameLen )
  331.                 {
  332.                     memcpy( ptr.bptr, AktuDI->TextFont->tf_Message.mn_Node.ln_Name, FontNameLen );
  333.                     ptr.bptr += FontNameLen;
  334.                 }
  335.  
  336.                 if( AktuDD->DisplayTyp == 3 )
  337.                 {
  338.                     memcpy( ptr.bptr , displaytab[ 3 ], 256 );
  339. /*                    ptr.bptr += 256;*/
  340.                 }
  341.  
  342.                 if( WriteChunkBytes( Handle, SettingsBuffer, SettingsBufferLen ))
  343.                 {
  344.                     Success = TRUE;
  345.                 }
  346.  
  347.                 FreeMem( SettingsBuffer, SettingsBufferLen );
  348.             }
  349.         }
  350.     }
  351.     CloseIFF(Handle);
  352.     }
  353.     Close(Handle -> iff_Stream);
  354.     }
  355.     FreeIFF(Handle);
  356.     }
  357.  
  358.     if((!quiet)&&(!Success))
  359.         MyRequest( MSG_INFO_GLOBAL_CANTSAVESETTINGS, ( ULONG )Name );
  360.  
  361.     return(Success);
  362. }
  363.  
  364. BOOL SaveSettingsFR(void)
  365. {
  366.     if( MyRequestFile( SettingsFullName, GetStr( MSG_WINDOWTITLE_SAVEFILEAS ), "#?.prefs", FALSE ))
  367.         return( SaveSettings( SettingsFullName, FALSE ));
  368.     else
  369.         return( FALSE );
  370. }
  371.  
  372. void SaveSettingsDefault(void)
  373. {
  374.     if( *SettingsFullName )
  375.         SaveSettings(SettingsFullName,FALSE);
  376.     else
  377.     {
  378.         if(!SaveSettings("FileX.prefs",TRUE))
  379.         {
  380.             BPTR lock;
  381.  
  382.             if(lock=Lock("ENVARC:FileX",ACCESS_READ))
  383.             {
  384.                 UnLock(lock);
  385.             }
  386.             else
  387.             {
  388.                 if(lock=CreateDir("ENVARC:FileX"))
  389.                     UnLock(lock);
  390.             }
  391.  
  392.             SaveSettings("ENVARC:FileX/FileX.prefs",TRUE);
  393.         }
  394.     }
  395. }
  396.  
  397. /********************* ARexxCommandSettings *********************/
  398.  
  399. BOOL LoadARexxCommands(UBYTE *Name)
  400. {
  401.     BOOL Success = FALSE;
  402.     BPTR fh;
  403.     long laenge,k;
  404.     UBYTE *mem,*ptr,*start;
  405.  
  406.     if(fh = Open(Name,MODE_OLDFILE))
  407.     {
  408.         if(laenge=GetFileLaenge(fh))
  409.         {
  410.             if(mem=ptr=AllocVec(laenge,MEMF_ANY))
  411.             {
  412.                 Read(fh,mem,laenge);
  413.  
  414.                 for( k = 0; ( k < 10 ) && ( ptr < mem + laenge ); k++ )
  415.                 {
  416.                     start = ptr;
  417.                     while(( *ptr != 0xa ) && ( ptr < mem + laenge )) ptr++;
  418.  
  419.                     if( ptr < mem + laenge )
  420.                     {
  421.                         *ptr++ = 0;
  422.  
  423.                         if( strlen( start ))
  424.                             SetARexxMenu( k, start );
  425.                         else
  426.                             SetEmptyARexxMenu( k );
  427.                     }
  428.                 }
  429.  
  430.                 for(;k<10;k++)
  431.                     SetEmptyARexxMenu( k );
  432.  
  433.                 if( Scr ) SetNewMenus();
  434.  
  435.                 Success = TRUE;
  436.                 
  437.                 FreeVec( mem );
  438.             }
  439.         }
  440.  
  441.         Close( fh );
  442.     }
  443.  
  444.     if( Success )
  445.         strcpy( ARexxCommandSettingsFullName, Name );
  446.  
  447.     return( Success );
  448. }
  449.  
  450. BOOL LoadARexxCommandsFR(void)
  451. {
  452.     if( MyRequestFile( ARexxCommandSettingsFullName, GetStr( MSG_WINDOWTITLE_LOADCOMMANDS ), "#?.prefs", FALSE ))
  453.         return( LoadARexxCommands( ARexxCommandSettingsFullName ));
  454.     else
  455.         return( FALSE );    
  456. }
  457.  
  458. void LoadARexxCommandsDefault(void)
  459. {
  460.     if(!LoadARexxCommands("FileXARexxCommands.prefs"))
  461.         LoadARexxCommands("ENVARC:FileX/FileXARexxCommands.prefs");
  462. }
  463.  
  464. BOOL SaveARexxCommands(UBYTE *Name)
  465. {
  466.     BOOL Success = FALSE;
  467.     BPTR fh;
  468.     long k;
  469.     BYTE lineend=0xa;
  470.  
  471.     if(fh=Open(Name,MODE_NEWFILE))
  472.     {
  473.         for(k=0;k<10;k++)
  474.         {
  475.             if(arexxcommandused[k] == TRUE)
  476.                 Write(fh, arexxcommands[k], strlen(arexxcommands[k]));
  477.  
  478.             Write(fh,&lineend,1);
  479.         }
  480.  
  481.         Success=TRUE;
  482.  
  483.         Close(fh);
  484.     }
  485.  
  486.     return(Success);
  487. }
  488.  
  489. BOOL SaveARexxCommandsFR(void)
  490. {
  491.     if( MyRequestFile( ARexxCommandSettingsFullName, GetStr( MSG_WINDOWTITLE_SAVECOMMANDS ), "#?.prefs", FALSE ))
  492.         return( SaveARexxCommands( ARexxCommandSettingsFullName ));
  493.     else
  494.         return( FALSE );    
  495. }
  496.  
  497. void SaveARexxCommandsDefault(void)
  498. {
  499.     if( *ARexxCommandSettingsFullName )
  500.         SaveARexxCommands( ARexxCommandSettingsFullName );
  501.     else
  502.     {
  503.         if(!SaveARexxCommands("FileXARexxCommands.prefs"))
  504.         {
  505.             BPTR lock;
  506.  
  507.             if(lock=Lock("ENVARC:FileX",ACCESS_READ))
  508.             {
  509.                 UnLock(lock);
  510.             }
  511.             else
  512.             {
  513.                 if(lock=CreateDir("ENVARC:FileX"))
  514.                     UnLock(lock);
  515.             }
  516.  
  517.             SaveARexxCommands("ENVARC:FileX/FileXARexxCommands.prefs");
  518.         }
  519.     }
  520. }
  521.